{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this is taken from https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html\n",
    "from collections import namedtuple\n",
    "\n",
    "Transition = namedtuple(\n",
    "    'Transition',\n",
    "    ('state', 'action', 'next_state', 'reward')\n",
    ")\n",
    "\n",
    "class ReplayMemory:\n",
    "    \"\"\"\n",
    "    Record past experiences for learning.\n",
    "    \"\"\"\n",
    "    def __init__(self, capacity=2000):\n",
    "        self.capacity = capacity\n",
    "        self.memory = []\n",
    "        self.position = 0\n",
    "\n",
    "    def push(self, *args):\n",
    "        \"\"\"Saves a transition.\"\"\"\n",
    "        if len(self.memory) < self.capacity:\n",
    "            self.memory.append(None)\n",
    "        self.memory[self.position] = Transition(*args)\n",
    "        self.position = (self.position + 1) % self.capacity\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        batch = random.sample(self.memory, batch_size)\n",
    "        batch = Transition(\n",
    "            *(np.array(el).reshape(batch_size, -1) for el in zip(*batch))\n",
    "        )\n",
    "        return batch\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.memory)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import numpy.matlib\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import optimizers\n",
    "from tensorflow.keras import initializers\n",
    "from tensorflow.keras import regularizers\n",
    "\n",
    "\n",
    "class DQNAgent():\n",
    "    def __init__(self, env, epsilon=1.0, lr=0.5, batch_size=128):\n",
    "        self.env = env\n",
    "        self.action_size = self.env.action_space.n\n",
    "        self.state_size = env.observation_space\n",
    "        self.memory = ReplayMemory()\n",
    "        self.epsilon = epsilon   # exploration factor\n",
    "        self.lr = lr       # Learning rate\n",
    "        self.batch_size = batch_size\n",
    "        self.model = self._build_model()\n",
    "        self.losses = []\n",
    "    \n",
    "    def _build_model(self):\n",
    "        model = tf.keras.Sequential([\n",
    "            layers.Dense(\n",
    "                100,\n",
    "                input_shape=(4,),\n",
    "                kernel_initializer=initializers.RandomNormal(stddev=5.0),\n",
    "                bias_initializer=initializers.Ones(),\n",
    "                # kernel_regularizer=regularizers.l1_l2(l1=1e-5, l2=1e-4),\n",
    "                activation='sigmoid',\n",
    "                name='state'\n",
    "            ),\n",
    "            layers.Dense(\n",
    "                2,\n",
    "                #input_shape=(4,),\n",
    "                activation='relu'\n",
    "            ),\n",
    "            layers.Dense(1, name='action', activation='tanh'),\n",
    "        ])\n",
    "        model.summary()\n",
    "        model.compile(\n",
    "            loss='hinge',\n",
    "            optimizer=optimizers.RMSprop(lr=self.lr)\n",
    "        )\n",
    "        return model\n",
    "       \n",
    "    def encode(self, state, action=None):\n",
    "        if action is None:\n",
    "            action = np.reshape(\n",
    "                list(range(self.action_size)),\n",
    "                (self.action_size, 1)\n",
    "            )\n",
    "            return np.hstack([\n",
    "                np.matlib.repmat(state, self.action_size, 1),\n",
    "                action\n",
    "            ])\n",
    "        return np.hstack([state, action])\n",
    "\n",
    "    def play(self, state):\n",
    "        \"\"\"\n",
    "        Choose which action to take, based on the observation. \n",
    "        Uses greedy epsilon for exploration/exploitation.\n",
    "        \"\"\"\n",
    "        state = np.reshape(state, (1, 3)).astype(float)\n",
    "        if np.random.rand() <= self.epsilon:\n",
    "            action = np.random.randint(0, self.action_size)\n",
    "        else:\n",
    "            action_value = self.model.predict(self.encode(state)).squeeze()\n",
    "            action = np.argmax(action_value)\n",
    "        \n",
    "        next_state1, reward, done, _ = self.env.step(action)\n",
    "        next_state = np.reshape(next_state1, (1, 3)).astype(float)\n",
    "        if done:\n",
    "            self.memory.push(state, action, next_state, reward)\n",
    "        return next_state1, reward, done\n",
    "\n",
    "    def learn(self):\n",
    "        effective_batch_size = min([len(self.memory), self.batch_size])\n",
    "        if effective_batch_size < 10:\n",
    "            return\n",
    "        #self.model.optimizer.set_state()\n",
    "        prev_loss = None\n",
    "        loss = None\n",
    "        patience = 0\n",
    "        i = 0\n",
    "        #while patience < 2 and i < 10:\n",
    "        batch = self.memory.sample(effective_batch_size)\n",
    "        # for more complex games we could take a wider horizon, like this:\n",
    "        #pred_rewards = self.model.predict(\n",
    "        #    self.encode(batch.next_state)\n",
    "        #).max(axis=1).reshape(self.batch_size, 1)\n",
    "        #learn_signal = batch.reward# + pred_rewards * self.gamma\n",
    "        #target = self.model.predict(\n",
    "        #    self.encode(batch.state))\n",
    "        #np.put_along_axis(\n",
    "        #    arr=target,\n",
    "        #    indices=batch.action,\n",
    "        #    values=learn_signal,\n",
    "        #    axis=1\n",
    "        #)\n",
    "        result = self.model.fit(\n",
    "            self.encode(batch.state, batch.action),\n",
    "            batch.reward,\n",
    "            epochs=1,\n",
    "            verbose=0\n",
    "        )\n",
    "        prev_loss = loss\n",
    "        loss = result.history['loss'][-1]\n",
    "        if prev_loss is not None and loss > prev_loss:\n",
    "            patience += 1\n",
    "        else:\n",
    "            patience = 0\n",
    "        i += 1\n",
    "        \n",
    "        self.losses.append(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "env = gym.make('Blackjack-v0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_5\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "state (Dense)                (None, 100)               500       \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 2)                 202       \n",
      "_________________________________________________________________\n",
      "action (Dense)               (None, 1)                 3         \n",
      "=================================================================\n",
      "Total params: 705\n",
      "Trainable params: 705\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "agent = DQNAgent(env=env, epsilon=0.01, lr=0.01, batch_size=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.memory.capacity = 20000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.batch_size = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "abd96391364c4d1b8994f86271e48f71",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average payout: -0.420\n",
      "0.5941007137298584\n",
      "average payout: -0.130\n",
      "0.7313433885574341\n",
      "average payout: -0.240\n",
      "0.7409286499023438\n",
      "average payout: -0.220\n",
      "0.7457007765769958\n",
      "average payout: -0.240\n",
      "0.7485693693161011\n",
      "average payout: -0.270\n",
      "0.7466313242912292\n",
      "average payout: -0.240\n",
      "0.7475041151046753\n",
      "average payout: -0.370\n",
      "0.7353308200836182\n",
      "average payout: -0.420\n",
      "0.715871274471283\n",
      "average payout: -0.290\n",
      "0.7160000205039978\n",
      "average payout: -0.220\n",
      "0.734000027179718\n",
      "average payout: -0.290\n",
      "0.7020000219345093\n",
      "average payout: -0.410\n",
      "0.7129999995231628\n",
      "average payout: -0.300\n",
      "0.703000009059906\n",
      "average payout: -0.100\n",
      "0.7149999737739563\n",
      "average payout: -0.120\n",
      "0.7139999866485596\n",
      "average payout: -0.360\n",
      "0.722000002861023\n",
      "average payout: -0.370\n",
      "0.7160000205039978\n",
      "average payout: -0.190\n",
      "0.7360000014305115\n",
      "average payout: -0.120\n",
      "0.718999981880188\n",
      "average payout: -0.080\n",
      "0.7149999737739563\n",
      "average payout: -0.190\n",
      "0.7590000033378601\n",
      "average payout: -0.370\n",
      "0.7710000276565552\n",
      "average payout: 0.000\n",
      "0.7519999742507935\n",
      "average payout: -0.140\n",
      "0.7239999771118164\n",
      "average payout: -0.320\n",
      "0.7360000014305115\n",
      "average payout: -0.120\n",
      "0.7760000228881836\n",
      "average payout: -0.230\n",
      "0.8220000267028809\n",
      "average payout: -0.140\n",
      "0.7329999804496765\n",
      "average payout: -0.100\n",
      "0.777999997138977\n",
      "average payout: -0.270\n",
      "0.7689999938011169\n",
      "average payout: -0.090\n",
      "0.8220000267028809\n",
      "average payout: -0.310\n",
      "0.7749999761581421\n",
      "average payout: -0.350\n",
      "0.7889999747276306\n",
      "average payout: -0.140\n",
      "0.7820000052452087\n",
      "average payout: -0.150\n",
      "0.7829999923706055\n",
      "average payout: -0.220\n",
      "0.7670000195503235\n",
      "average payout: -0.140\n",
      "0.7639999985694885\n",
      "average payout: -0.280\n",
      "0.7599999904632568\n",
      "average payout: -0.170\n",
      "0.7829999923706055\n",
      "average payout: -0.290\n",
      "0.7829999923706055\n",
      "average payout: -0.140\n",
      "0.7829999923706055\n",
      "average payout: -0.230\n",
      "0.7829999923706055\n",
      "average payout: -0.280\n",
      "0.7829999923706055\n",
      "average payout: -0.120\n",
      "0.7829999923706055\n",
      "average payout: -0.090\n",
      "0.7829999923706055\n",
      "average payout: -0.240\n",
      "0.7829999923706055\n",
      "average payout: -0.230\n",
      "0.7829999923706055\n",
      "average payout: -0.250\n",
      "0.7829999923706055\n",
      "\n",
      "best 100 average: 0.070\n"
     ]
    }
   ],
   "source": [
    "from tqdm.notebook import trange\n",
    "\n",
    "num_rounds = 5000\n",
    "exploit_runs = num_rounds // 5\n",
    "best_100 = -1.0\n",
    "\n",
    "payouts = []\n",
    "epsilons = np.hstack([\n",
    "    np.linspace(0.5, 0.01, num=num_rounds - exploit_runs), \n",
    "    np.zeros(exploit_runs)\n",
    "])\n",
    "for sample in trange(num_rounds):\n",
    "    epsilon = epsilons[sample]\n",
    "    agent.epsilon = epsilon\n",
    "    total_payout = 0\n",
    "    state = agent.env.reset()\n",
    "    for _ in range(10):\n",
    "        state, payout, done = agent.play(state)\n",
    "        total_payout += payout\n",
    "        if done:\n",
    "            break\n",
    "    if epsilon > 0:\n",
    "        agent.learn()\n",
    "    \n",
    "    mean_100 = np.mean(payouts[-100:])\n",
    "    if mean_100 > best_100:\n",
    "        best_100 = mean_100\n",
    "\n",
    "    payouts.append(total_payout)\n",
    "    if (sample % 100) == 0 and sample >= 100:\n",
    "        \n",
    "        print('average payout: {:.3f}'.format(\n",
    "            mean_100\n",
    "        ))\n",
    "        print(agent.losses[-1])\n",
    "        \n",
    "print('best 100 average: {:.3f}'.format(best_100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f28a06e6a90>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from scipy.ndimage.filters import uniform_filter1d\n",
    "import matplotlib\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "font = {'family' : 'normal',\n",
    "        'weight' : 'bold',\n",
    "        'size'   : 12}\n",
    "matplotlib.rc('font', **font)\n",
    "\n",
    "#plt.plot(payouts)           \n",
    "plt.xlabel('episodes')\n",
    "plt.ylabel('payouts')\n",
    "plt.plot(uniform_filter1d(payouts, size=1000))\n",
    "plt.plot(uniform_filter1d(payouts, size=100))\n",
    "#plt.plot(uniform_filter1d(agent.losses, size=100))\n",
    "plt.legend([\n",
    "    'payouts runavg 1000',\n",
    "    'payouts runavg 100',\n",
    "    #'training losses runavg 100',\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
